home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 1998 August / PC Plus SuperCD 50a Issue 142 (CD142a) (August 1998).iso / trial / demon / TURNPIKE.1 / CLASSES.ZIP / JAVA / AWT / GridBagLayout.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-04-14  |  7.5 KB  |  672 lines
  1. package java.awt;
  2.  
  3. import java.util.Hashtable;
  4.  
  5. public class GridBagLayout implements LayoutManager {
  6.    protected static final int MAXGRIDSIZE = 128;
  7.    protected static final int MINSIZE = 1;
  8.    protected static final int PREFERREDSIZE = 2;
  9.    protected Hashtable comptable = new Hashtable();
  10.    protected GridBagConstraints defaultConstraints = new GridBagConstraints();
  11.    protected GridBagLayoutInfo layoutInfo;
  12.    public int[] columnWidths;
  13.    public int[] rowHeights;
  14.    public double[] columnWeights;
  15.    public double[] rowWeights;
  16.  
  17.    public void setConstraints(Component var1, GridBagConstraints var2) {
  18.       this.comptable.put(var1, var2.clone());
  19.    }
  20.  
  21.    public GridBagConstraints getConstraints(Component var1) {
  22.       GridBagConstraints var2 = (GridBagConstraints)this.comptable.get(var1);
  23.       if (var2 == null) {
  24.          this.setConstraints(var1, this.defaultConstraints);
  25.          var2 = (GridBagConstraints)this.comptable.get(var1);
  26.       }
  27.  
  28.       return (GridBagConstraints)var2.clone();
  29.    }
  30.  
  31.    protected GridBagConstraints lookupConstraints(Component var1) {
  32.       GridBagConstraints var2 = (GridBagConstraints)this.comptable.get(var1);
  33.       if (var2 == null) {
  34.          this.setConstraints(var1, this.defaultConstraints);
  35.          var2 = (GridBagConstraints)this.comptable.get(var1);
  36.       }
  37.  
  38.       return var2;
  39.    }
  40.  
  41.    public Point getLayoutOrigin() {
  42.       Point var1 = new Point(0, 0);
  43.       if (this.layoutInfo != null) {
  44.          var1.x = this.layoutInfo.startx;
  45.          var1.y = this.layoutInfo.starty;
  46.       }
  47.  
  48.       return var1;
  49.    }
  50.  
  51.    public int[][] getLayoutDimensions() {
  52.       if (this.layoutInfo == null) {
  53.          return new int[2][0];
  54.       } else {
  55.          int[][] var1 = new int[][]{new int[this.layoutInfo.width], new int[this.layoutInfo.height]};
  56.          System.arraycopy(this.layoutInfo.minWidth, 0, var1[0], 0, this.layoutInfo.width);
  57.          System.arraycopy(this.layoutInfo.minHeight, 0, var1[1], 0, this.layoutInfo.height);
  58.          return var1;
  59.       }
  60.    }
  61.  
  62.    public double[][] getLayoutWeights() {
  63.       if (this.layoutInfo == null) {
  64.          return new double[2][0];
  65.       } else {
  66.          double[][] var1 = new double[][]{new double[this.layoutInfo.width], new double[this.layoutInfo.height]};
  67.          System.arraycopy(this.layoutInfo.weightX, 0, var1[0], 0, this.layoutInfo.width);
  68.          System.arraycopy(this.layoutInfo.weightY, 0, var1[1], 0, this.layoutInfo.height);
  69.          return var1;
  70.       }
  71.    }
  72.  
  73.    public Point location(int var1, int var2) {
  74.       Point var3 = new Point(0, 0);
  75.       if (this.layoutInfo == null) {
  76.          return var3;
  77.       } else {
  78.          int var5 = this.layoutInfo.startx;
  79.  
  80.          int var4;
  81.          for(var4 = 0; var4 < this.layoutInfo.width; ++var4) {
  82.             var5 += this.layoutInfo.minWidth[var4];
  83.             if (var5 > var1) {
  84.                break;
  85.             }
  86.          }
  87.  
  88.          var3.x = var4;
  89.          var5 = this.layoutInfo.starty;
  90.  
  91.          for(var4 = 0; var4 < this.layoutInfo.height; ++var4) {
  92.             var5 += this.layoutInfo.minHeight[var4];
  93.             if (var5 > var2) {
  94.                break;
  95.             }
  96.          }
  97.  
  98.          var3.y = var4;
  99.          return var3;
  100.       }
  101.    }
  102.  
  103.    public void addLayoutComponent(String var1, Component var2) {
  104.    }
  105.  
  106.    public void removeLayoutComponent(Component var1) {
  107.    }
  108.  
  109.    public Dimension preferredLayoutSize(Container var1) {
  110.       GridBagLayoutInfo var2 = this.GetLayoutInfo(var1, 2);
  111.       return this.GetMinSize(var1, var2);
  112.    }
  113.  
  114.    public Dimension minimumLayoutSize(Container var1) {
  115.       GridBagLayoutInfo var2 = this.GetLayoutInfo(var1, 1);
  116.       return this.GetMinSize(var1, var2);
  117.    }
  118.  
  119.    public void layoutContainer(Container var1) {
  120.       this.ArrangeGrid(var1);
  121.    }
  122.  
  123.    public String toString() {
  124.       return this.getClass().getName();
  125.    }
  126.  
  127.    protected GridBagLayoutInfo GetLayoutInfo(Container var1, int var2) {
  128.       GridBagLayoutInfo var3 = new GridBagLayoutInfo();
  129.       Component[] var7 = var1.getComponents();
  130.       var3.width = var3.height = 0;
  131.       int var20 = -1;
  132.       int var19 = -1;
  133.       int[] var25 = new int[128];
  134.       int[] var26 = new int[128];
  135.  
  136.       for(int var8 = 0; var8 < var7.length; ++var8) {
  137.          Component var4 = var7[var8];
  138.          if (var4.isVisible()) {
  139.             GridBagConstraints var5 = this.lookupConstraints(var4);
  140.             int var15 = var5.gridx;
  141.             int var16 = var5.gridy;
  142.             int var17 = var5.gridwidth;
  143.             if (var17 <= 0) {
  144.                var17 = 1;
  145.             }
  146.  
  147.             int var18 = var5.gridheight;
  148.             if (var18 <= 0) {
  149.                var18 = 1;
  150.             }
  151.  
  152.             if (var15 < 0 && var16 < 0) {
  153.                if (var19 >= 0) {
  154.                   var16 = var19;
  155.                } else if (var20 >= 0) {
  156.                   var15 = var20;
  157.                } else {
  158.                   var16 = 0;
  159.                }
  160.             }
  161.  
  162.             if (var15 < 0) {
  163.                int var11 = 0;
  164.  
  165.                for(int var9 = var16; var9 < var16 + var18; ++var9) {
  166.                   int var27 = var25[var9];
  167.                   var11 = var11 >= var27 ? var11 : var27;
  168.                }
  169.  
  170.                var15 = var11 - var15 - 1;
  171.                if (var15 < 0) {
  172.                   var15 = 0;
  173.                }
  174.             } else if (var16 < 0) {
  175.                int var12 = 0;
  176.  
  177.                for(int var37 = var15; var37 < var15 + var17; ++var37) {
  178.                   int var77 = var26[var37];
  179.                   var12 = var12 >= var77 ? var12 : var77;
  180.                }
  181.  
  182.                var16 = var12 - var16 - 1;
  183.                if (var16 < 0) {
  184.                   var16 = 0;
  185.                }
  186.             }
  187.  
  188.             int var56;
  189.             for(var56 = var15 + var17; var3.width < var56; ++var3.width) {
  190.             }
  191.  
  192.             int var60;
  193.             for(var60 = var16 + var18; var3.height < var60; ++var3.height) {
  194.             }
  195.  
  196.             for(int var38 = var15; var38 < var15 + var17; ++var38) {
  197.                var26[var38] = var60;
  198.             }
  199.  
  200.             for(int var39 = var16; var39 < var16 + var18; ++var39) {
  201.                var25[var39] = var56;
  202.             }
  203.  
  204.             Dimension var6;
  205.             if (var2 == 2) {
  206.                var6 = var4.preferredSize();
  207.             } else {
  208.                var6 = var4.minimumSize();
  209.             }
  210.  
  211.             var5.minWidth = var6.width;
  212.             var5.minHeight = var6.height;
  213.             if (var5.gridheight == 0 && var5.gridwidth == 0) {
  214.                var20 = -1;
  215.                var19 = -1;
  216.             }
  217.  
  218.             if (var5.gridheight == 0 && var19 < 0) {
  219.                var20 = var15 + var17;
  220.             } else if (var5.gridwidth == 0 && var20 < 0) {
  221.                var19 = var16 + var18;
  222.             }
  223.          }
  224.       }
  225.  
  226.       if (this.columnWidths != null && var3.width < this.columnWidths.length) {
  227.          var3.width = this.columnWidths.length;
  228.       }
  229.  
  230.       if (this.rowHeights != null && var3.height < this.rowHeights.length) {
  231.          var3.height = this.rowHeights.length;
  232.       }
  233.  
  234.       var20 = -1;
  235.       var19 = -1;
  236.       var25 = new int[128];
  237.       var26 = new int[128];
  238.  
  239.       for(int var35 = 0; var35 < var7.length; ++var35) {
  240.          Component var31 = var7[var35];
  241.          if (var31.isVisible()) {
  242.             GridBagConstraints var33 = this.lookupConstraints(var31);
  243.             int var65 = var33.gridx;
  244.             int var66 = var33.gridy;
  245.             int var67 = var33.gridwidth;
  246.             int var68 = var33.gridheight;
  247.             if (var65 < 0 && var66 < 0) {
  248.                if (var19 >= 0) {
  249.                   var66 = var19;
  250.                } else if (var20 >= 0) {
  251.                   var65 = var20;
  252.                } else {
  253.                   var66 = 0;
  254.                }
  255.             }
  256.  
  257.             if (var65 < 0) {
  258.                if (var68 <= 0) {
  259.                   var68 += var3.height - var66;
  260.                   if (var68 < 1) {
  261.                      var68 = 1;
  262.                   }
  263.                }
  264.  
  265.                int var57 = 0;
  266.  
  267.                for(int var40 = var66; var40 < var66 + var68; ++var40) {
  268.                   int var78 = var25[var40];
  269.                   var57 = var57 >= var78 ? var57 : var78;
  270.                }
  271.  
  272.                var65 = var57 - var65 - 1;
  273.                if (var65 < 0) {
  274.                   var65 = 0;
  275.                }
  276.             } else if (var66 < 0) {
  277.                if (var67 <= 0) {
  278.                   var67 += var3.width - var65;
  279.                   if (var67 < 1) {
  280.                      var67 = 1;
  281.                   }
  282.                }
  283.  
  284.                int var61 = 0;
  285.  
  286.                for(int var41 = var65; var41 < var65 + var67; ++var41) {
  287.                   int var79 = var26[var41];
  288.                   var61 = var61 >= var79 ? var61 : var79;
  289.                }
  290.  
  291.                var66 = var61 - var66 - 1;
  292.                if (var66 < 0) {
  293.                   var66 = 0;
  294.                }
  295.             }
  296.  
  297.             if (var67 <= 0) {
  298.                var67 += var3.width - var65;
  299.                if (var67 < 1) {
  300.                   var67 = 1;
  301.                }
  302.             }
  303.  
  304.             if (var68 <= 0) {
  305.                var68 += var3.height - var66;
  306.                if (var68 < 1) {
  307.                   var68 = 1;
  308.                }
  309.             }
  310.  
  311.             int var58 = var65 + var67;
  312.             int var62 = var66 + var68;
  313.  
  314.             for(int var42 = var65; var42 < var65 + var67; ++var42) {
  315.                var26[var42] = var62;
  316.             }
  317.  
  318.             for(int var43 = var66; var43 < var66 + var68; ++var43) {
  319.                var25[var43] = var58;
  320.             }
  321.  
  322.             if (var33.gridheight == 0 && var33.gridwidth == 0) {
  323.                var20 = -1;
  324.                var19 = -1;
  325.             }
  326.  
  327.             if (var33.gridheight == 0 && var19 < 0) {
  328.                var20 = var65 + var67;
  329.             } else if (var33.gridwidth == 0 && var20 < 0) {
  330.                var19 = var66 + var68;
  331.             }
  332.  
  333.             var33.tempX = var65;
  334.             var33.tempY = var66;
  335.             var33.tempWidth = var67;
  336.             var33.tempHeight = var68;
  337.          }
  338.       }
  339.  
  340.       if (this.columnWidths != null) {
  341.          System.arraycopy(this.columnWidths, 0, var3.minWidth, 0, this.columnWidths.length);
  342.       }
  343.  
  344.       if (this.rowHeights != null) {
  345.          System.arraycopy(this.rowHeights, 0, var3.minHeight, 0, this.rowHeights.length);
  346.       }
  347.  
  348.       if (this.columnWeights != null) {
  349.          System.arraycopy(this.columnWeights, 0, var3.weightX, 0, this.columnWeights.length);
  350.       }
  351.  
  352.       if (this.rowWeights != null) {
  353.          System.arraycopy(this.rowWeights, 0, var3.weightY, 0, this.rowWeights.length);
  354.       }
  355.  
  356.       int var14 = Integer.MAX_VALUE;
  357.  
  358.       for(int var44 = 1; var44 != Integer.MAX_VALUE; var14 = Integer.MAX_VALUE) {
  359.          for(int var36 = 0; var36 < var7.length; ++var36) {
  360.             Component var32 = var7[var36];
  361.             if (var32.isVisible()) {
  362.                GridBagConstraints var34 = this.lookupConstraints(var32);
  363.                if (var34.tempWidth == var44) {
  364.                   int var59 = var34.tempX + var34.tempWidth;
  365.                   double var21 = var34.weightx;
  366.  
  367.                   for(int var10 = var34.tempX; var10 < var59; ++var10) {
  368.                      var21 -= var3.weightX[var10];
  369.                   }
  370.  
  371.                   if (var21 > (double)0.0F) {
  372.                      double var23 = (double)0.0F;
  373.  
  374.                      for(int var45 = var34.tempX; var45 < var59; ++var45) {
  375.                         var23 += var3.weightX[var45];
  376.                      }
  377.  
  378.                      for(int var46 = var34.tempX; var23 > (double)0.0F && var46 < var59; ++var46) {
  379.                         double var80 = var3.weightX[var46];
  380.                         double var29 = var80 * var21 / var23;
  381.                         double[] var10000 = var3.weightX;
  382.                         var10000[var46] += var29;
  383.                         var21 -= var29;
  384.                         var23 -= var80;
  385.                      }
  386.  
  387.                      double[] var87 = var3.weightX;
  388.                      var87[var59 - 1] += var21;
  389.                   }
  390.  
  391.                   int var13 = var34.minWidth + var34.ipadx + var34.insets.left + var34.insets.right;
  392.  
  393.                   for(int var47 = var34.tempX; var47 < var59; ++var47) {
  394.                      var13 -= var3.minWidth[var47];
  395.                   }
  396.  
  397.                   if (var13 > 0) {
  398.                      double var72 = (double)0.0F;
  399.  
  400.                      for(int var48 = var34.tempX; var48 < var59; ++var48) {
  401.                         var72 += var3.weightX[var48];
  402.                      }
  403.  
  404.                      for(int var49 = var34.tempX; var72 > (double)0.0F && var49 < var59; ++var49) {
  405.                         double var81 = var3.weightX[var49];
  406.                         int var84 = (int)(var81 * (double)var13 / var72);
  407.                         int[] var88 = var3.minWidth;
  408.                         var88[var49] += var84;
  409.                         var13 -= var84;
  410.                         var72 -= var81;
  411.                      }
  412.  
  413.                      int[] var89 = var3.minWidth;
  414.                      var89[var59 - 1] += var13;
  415.                   }
  416.                } else if (var34.tempWidth > var44 && var34.tempWidth < var14) {
  417.                   var14 = var34.tempWidth;
  418.                }
  419.  
  420.                if (var34.tempHeight != var44) {
  421.                   if (var34.tempHeight > var44 && var34.tempHeight < var14) {
  422.                      var14 = var34.tempHeight;
  423.                   }
  424.                } else {
  425.                   int var63 = var34.tempY + var34.tempHeight;
  426.                   double var71 = var34.weighty;
  427.  
  428.                   for(int var50 = var34.tempY; var50 < var63; ++var50) {
  429.                      var71 -= var3.weightY[var50];
  430.                   }
  431.  
  432.                   if (var71 > (double)0.0F) {
  433.                      double var73 = (double)0.0F;
  434.  
  435.                      for(int var51 = var34.tempY; var51 < var63; ++var51) {
  436.                         var73 += var3.weightY[var51];
  437.                      }
  438.  
  439.                      for(int var52 = var34.tempY; var73 > (double)0.0F && var52 < var63; ++var52) {
  440.                         double var82 = var3.weightY[var52];
  441.                         double var85 = var82 * var71 / var73;
  442.                         double[] var90 = var3.weightY;
  443.                         var90[var52] += var85;
  444.                         var71 -= var85;
  445.                         var73 -= var82;
  446.                      }
  447.  
  448.                      double[] var91 = var3.weightY;
  449.                      var91[var63 - 1] += var71;
  450.                   }
  451.  
  452.                   int var64 = var34.minHeight + var34.ipady + var34.insets.top + var34.insets.bottom;
  453.  
  454.                   for(int var53 = var34.tempY; var53 < var63; ++var53) {
  455.                      var64 -= var3.minHeight[var53];
  456.                   }
  457.  
  458.                   if (var64 > 0) {
  459.                      double var74 = (double)0.0F;
  460.  
  461.                      for(int var54 = var34.tempY; var54 < var63; ++var54) {
  462.                         var74 += var3.weightY[var54];
  463.                      }
  464.  
  465.                      for(int var55 = var34.tempY; var74 > (double)0.0F && var55 < var63; ++var55) {
  466.                         double var83 = var3.weightY[var55];
  467.                         int var86 = (int)(var83 * (double)var64 / var74);
  468.                         int[] var92 = var3.minHeight;
  469.                         var92[var55] += var86;
  470.                         var64 -= var86;
  471.                         var74 -= var83;
  472.                      }
  473.  
  474.                      int[] var93 = var3.minHeight;
  475.                      var93[var63 - 1] += var64;
  476.                   }
  477.                }
  478.             }
  479.          }
  480.  
  481.          var44 = var14;
  482.       }
  483.  
  484.       return var3;
  485.    }
  486.  
  487.    protected void AdjustForGravity(GridBagConstraints var1, Rectangle var2) {
  488.       var2.x += var1.insets.left;
  489.       var2.width -= var1.insets.left + var1.insets.right;
  490.       var2.y += var1.insets.top;
  491.       var2.height -= var1.insets.top + var1.insets.bottom;
  492.       int var3 = 0;
  493.       if (var1.fill != 2 && var1.fill != 1 && var2.width > var1.minWidth + var1.ipadx) {
  494.          var3 = var2.width - (var1.minWidth + var1.ipadx);
  495.          var2.width = var1.minWidth + var1.ipadx;
  496.       }
  497.  
  498.       int var4 = 0;
  499.       if (var1.fill != 3 && var1.fill != 1 && var2.height > var1.minHeight + var1.ipady) {
  500.          var4 = var2.height - (var1.minHeight + var1.ipady);
  501.          var2.height = var1.minHeight + var1.ipady;
  502.       }
  503.  
  504.       switch (var1.anchor) {
  505.          case 10:
  506.             var2.x += var3 / 2;
  507.             var2.y += var4 / 2;
  508.             return;
  509.          case 11:
  510.             var2.x += var3 / 2;
  511.             return;
  512.          case 12:
  513.             var2.x += var3;
  514.             return;
  515.          case 13:
  516.             var2.x += var3;
  517.             var2.y += var4 / 2;
  518.             return;
  519.          case 14:
  520.             var2.x += var3;
  521.             var2.y += var4;
  522.             return;
  523.          case 15:
  524.             var2.x += var3 / 2;
  525.             var2.y += var4;
  526.             return;
  527.          case 16:
  528.             var2.y += var4;
  529.             return;
  530.          case 17:
  531.             var2.y += var4 / 2;
  532.             return;
  533.          case 18:
  534.             return;
  535.          default:
  536.             throw new IllegalArgumentException("illegal anchor value");
  537.       }
  538.    }
  539.  
  540.    protected Dimension GetMinSize(Container var1, GridBagLayoutInfo var2) {
  541.       Dimension var3 = new Dimension();
  542.       Insets var6 = var1.insets();
  543.       int var5 = 0;
  544.  
  545.       for(int var4 = 0; var4 < var2.width; ++var4) {
  546.          var5 += var2.minWidth[var4];
  547.       }
  548.  
  549.       var3.width = var5 + var6.left + var6.right;
  550.       var5 = 0;
  551.  
  552.       for(int var7 = 0; var7 < var2.height; ++var7) {
  553.          var5 += var2.minHeight[var7];
  554.       }
  555.  
  556.       var3.height = var5 + var6.top + var6.bottom;
  557.       return var3;
  558.    }
  559.  
  560.    protected void ArrangeGrid(Container var1) {
  561.       Insets var5 = var1.insets();
  562.       Component[] var6 = var1.getComponents();
  563.       Rectangle var8 = new Rectangle();
  564.       if (var6.length != 0 || this.columnWidths != null && this.columnWidths.length != 0 || this.rowHeights != null && this.rowHeights.length != 0) {
  565.          GridBagLayoutInfo var14 = this.GetLayoutInfo(var1, 2);
  566.          Dimension var7 = this.GetMinSize(var1, var14);
  567.          if (var7.width < var1.width || var7.height < var1.height) {
  568.             var14 = this.GetLayoutInfo(var1, 1);
  569.             var7 = this.GetMinSize(var1, var14);
  570.          }
  571.  
  572.          this.layoutInfo = var14;
  573.          var8.width = var7.width;
  574.          var8.height = var7.height;
  575.          int var10 = var1.width - var8.width;
  576.          if (var10 != 0) {
  577.             double var12 = (double)0.0F;
  578.  
  579.             for(int var9 = 0; var9 < var14.width; ++var9) {
  580.                var12 += var14.weightX[var9];
  581.             }
  582.  
  583.             if (var12 > (double)0.0F) {
  584.                for(int var16 = 0; var16 < var14.width; ++var16) {
  585.                   int var15 = (int)((double)var10 * var14.weightX[var16] / var12);
  586.                   int[] var10000 = var14.minWidth;
  587.                   var10000[var16] += var15;
  588.                   var8.width += var15;
  589.                   if (var14.minWidth[var16] < 0) {
  590.                      var8.width -= var14.minWidth[var16];
  591.                      var14.minWidth[var16] = 0;
  592.                   }
  593.                }
  594.             }
  595.  
  596.             var10 = var1.width - var8.width;
  597.          } else {
  598.             var10 = 0;
  599.          }
  600.  
  601.          int var11 = var1.height - var8.height;
  602.          if (var11 != 0) {
  603.             double var25 = (double)0.0F;
  604.  
  605.             for(int var17 = 0; var17 < var14.height; ++var17) {
  606.                var25 += var14.weightY[var17];
  607.             }
  608.  
  609.             if (var25 > (double)0.0F) {
  610.                for(int var18 = 0; var18 < var14.height; ++var18) {
  611.                   int var26 = (int)((double)var11 * var14.weightY[var18] / var25);
  612.                   int[] var27 = var14.minHeight;
  613.                   var27[var18] += var26;
  614.                   var8.height += var26;
  615.                   if (var14.minHeight[var18] < 0) {
  616.                      var8.height -= var14.minHeight[var18];
  617.                      var14.minHeight[var18] = 0;
  618.                   }
  619.                }
  620.             }
  621.  
  622.             var11 = var1.height - var8.height;
  623.          } else {
  624.             var11 = 0;
  625.          }
  626.  
  627.          var14.startx = var10 / 2 + var5.left;
  628.          var14.starty = var11 / 2 + var5.top;
  629.  
  630.          for(int var3 = 0; var3 < var6.length; ++var3) {
  631.             Component var2 = var6[var3];
  632.             if (var2.isVisible()) {
  633.                GridBagConstraints var4 = this.lookupConstraints(var2);
  634.                var8.x = var14.startx;
  635.  
  636.                for(int var19 = 0; var19 < var4.tempX; ++var19) {
  637.                   var8.x += var14.minWidth[var19];
  638.                }
  639.  
  640.                var8.y = var14.starty;
  641.  
  642.                for(int var20 = 0; var20 < var4.tempY; ++var20) {
  643.                   var8.y += var14.minHeight[var20];
  644.                }
  645.  
  646.                var8.width = 0;
  647.  
  648.                for(int var21 = var4.tempX; var21 < var4.tempX + var4.tempWidth; ++var21) {
  649.                   var8.width += var14.minWidth[var21];
  650.                }
  651.  
  652.                var8.height = 0;
  653.  
  654.                for(int var22 = var4.tempY; var22 < var4.tempY + var4.tempHeight; ++var22) {
  655.                   var8.height += var14.minHeight[var22];
  656.                }
  657.  
  658.                this.AdjustForGravity(var4, var8);
  659.                if (var8.width > 0 && var8.height > 0) {
  660.                   if (var2.x != var8.x || var2.y != var8.y || var2.width != var8.width || var2.height != var8.height) {
  661.                      var2.reshape(var8.x, var8.y, var8.width, var8.height);
  662.                   }
  663.                } else {
  664.                   var2.reshape(0, 0, 0, 0);
  665.                }
  666.             }
  667.          }
  668.  
  669.       }
  670.    }
  671. }
  672.